Tudo o que você precisa saber para usar os argumentos do qgraph e melhorar o visual das suas redes, além de outras funções úteis do pacote.

qgraph()


Vamos começar com a função qgraph(), usada para plotar redes.

O primeiro argumento de qgraph é input. O input pode ser uma matriz de adjacência (matriz N x N com diagonal 0 e com valores 0 e 1 distribuídos nas linhas e colunas), uma matriz ponderada (uma matriz N x N com valores diferentes de 0 e 1 nas linhas e colunas). Pode também ser matriz de correlações, objetos de classe "sem","lavaan", "principal", ou o resultado do glasso. Pode também ser uma matriz de adjacência ponderada (matriz N x N, diagonal 0 e valores quaisquer nas linhas e colunas).

Primeiro, vamos olhar para redes não ponderadas diretas (unweighted direct networks/graphs). Nesse caso, uma matriz não ponderada direta é a mesma coisa do que uma matriz de adjacência:

  • 1 indica uma conexão

  • 0 não indica conexão

  • As linhas são os nodos de origem (a seta começa neles)

  • As colunas são os nodos de destino (a seta termina neles)

library(qgraph)
input <- matrix(c(0,1,1,
                  0,0,1,
                  0,0,0),3,3,byrow=TRUE) ## Essa e uma matriz não ponderada direta (flechas)
qgraph(input)


Para fazermos uma rede com valores/ponderada, precisamos colocar valores nas arestas (que são os valores da matriz). Para fazer isso, simplesmente especifique valores que não são somente 1 e 0. Valores negativos têm a mesma força que valores positivos.

input2 <- matrix(c(0,1,3,
                  0,0,4,
                  0,0,0),3,3,byrow=TRUE)
qgraph(input2)


O exemplo acima é de uma rede ponderada direta (setas). Agora, para fazer redes indiretas (que só mostram o relacionamento, mas não a direção), precisamos criar uma matriz que tenha valores iguais tanto acima quanto abaixo da diagonal, assim como em uma matriz de correlação. Lembrando que a diagonal continua 0.

input3 <- matrix(c(0,-1,3,
                  -1,0,4,
                  3,4,0),3,3,byrow=TRUE)

## Repare que a linha 1 coluna 2 é igual a linha 2 coluna 1.

qgraph(input3)


E se colocarmos um número 1 na diagonal (como no caso da correlação de uma variável com ela mesma), o que acontece?

input4 <- matrix(c(0,1,3,
                   1,1,4,
                   3,4,0),3,3,byrow=TRUE)
qgraph(input4)


Veja que surgiu uma aresta no nodo 2 que se liga nesse próprio nodo.

Normalmente, com variáveis psicológicas, vamos usar o resultado de uma matriz de adjacência estimada, seja por correlações, correlações parciais, mgm, Ising model, entre outros métodos.

Vamos criar uma rede de correlações com 10 itens de um questionário de personalidade.

library(psych)
bfi <- na.omit(bfi[, 1:10])
cor <- cor_auto(bfi)
qgraph(cor)


Observe que o qgraph reconhece que a entrada é uma matriz de correlação e reconhece que a diagonal é a correlação da variável com ela mesma. Um argumento faz com que essas correlações não apareçam na rede.



Argumentos estéticos

Agrupamento

groups

Esse argumento é usado quando você deseja formar grupos a partir das suas variáveis. Como exemplo, estamos usando um banco de dados que nos mostra variáveis A e C. Os nodos que possuem essas letras podem ser classificados em grupos: Agreeableness e Consciousness. Vamos criar um vetor para agrupar essas variáveis.

grupos <- c(rep("Agreeableness",5), rep("Consciousness", 5))
grupos 
##  [1] "Agreeableness" "Agreeableness" "Agreeableness" "Agreeableness"
##  [5] "Agreeableness" "Consciousness" "Consciousness" "Consciousness"
##  [9] "Consciousness" "Consciousness"

Pedimos para o R fazer um vetor com os nomes Agreeableness (repetido 5 vezes) e Consciousness (repetido 5 vezes). O primeiro valor do vetor (“Agreeableness”) vai se “juntar” com a coluna 1 da matriz colocada no qgraph. O segundo vai se juntar com a coluna 2, e assim por diante.

qgraph(cor, groups = grupos)


Uma legenda foi criada automaticamente para indicar as cores dos grupos.


Legenda, título, margem e tamanho da rede

Legenda

legend

Lógico e indica se a legenda deve ser plotada. Default é TRUE se groups ou nodeNames forem colocados.


legend.cex

Valor que indica o tamanho da legenda. Ele só funciona quando groups ou nodeNames são usados, uma vez que esses argumentos “ativam” a legenda.

qgraph(cor, groups = grupos, legend.cex = 0.9)


Título

title

Indica o título da rede. Colocar entre aspas.


title.cex

Número que indica o tamanho do título. O default é 1.

qgraph(cor, title = "Rede 1", title.cex = 1.75)


Margem

mar

É um argumento para mudar as margens. Você coloca ele dentro da função qgraph(). mar recebe 4 valores: c(baixo, esquerda, cima, direita). Quando for usar, lembre-se que você precisa colocar os 4 valores para dar certo. O default é c(3, 3, 3, 3).

qgraph(cor, mar = c(8,3,5,10))

Tamanho da rede

Dois argumentos podem ser passados para mudar o tamanho da rede. Sugere-se que, quando a rede for plotada com legenda, a figura como um todo fica com uma melhor visualização quando a largura for 1,4x maior que a altura. Porém, você pode mudar esse valor como achar necessário. O padrão para width e height é 7 polegadas.

width

Valor que modifica a largura, em polegadas.


height

Valor que modifica a altura, em polegadas.

qgraph(cor, width = 14, height = 10, groups = grupos)


GLratio

Tamanho relativo do gráfico comparado ao layout. Default é 2.5.


Tema, background e paletas de cores predefinidas

theme

Existem diversos temas para aplicar na rede. Esses temas normalmente mudam a paleta de cores dos nodos e as cores das arestas.


  • "classic": tema clássico. Arestas verdes (positiva) e arestas vermelhas (negativas). Cores padrão RGB.
qgraph(cor, theme = "classic", groups = grupos)


  • "colorblind": para superar o daltonismo, as arestas positivas são azuis.
qgraph(cor, theme = "colorblind", groups = grupos)


  • "gray": o tema todo fica preto e branco. Arestas negativas ficam pontilhadas.
qgraph(cor, theme = "gray", groups = grupos)


  • "Borkulo": arestas positivas azuis (mais escuro) e negativas vermelhas (mais claro).
qgraph(cor, theme = "Borkulo", groups = grupos)


palette

Quando você for agrupar os nodos (groups), você pode optar por diferentes paletas de cores. Não esqueça das “aspas”.


  • "rainbow": é o padrão.


  • "colorblind": as cores dos nodos mudam. Note que são as mesmas cores do tema “colorblind”. Apenas as arestas continuam com as cores do tema clássico.
qgraph(cor, palette = "colorblind", groups = grupos)


  • "pastel": outra seleção de cores.
qgraph(cor, palette = "pastel", groups = grupos)


  • "ggplot2": outras cores para nodos.
qgraph(cor, palette = "ggplot2", groups = grupos)


bg

Esse argumento muda a cor do background. Você pode colocar o nome de uma cor em inglês (e.g., “green”) ou também os valores hex de uma cor. Tanto o nome quanto o valor hex funcionam em todos os argumentos de cores do qgraph. Lembre-se de colocar entre aspas.

qgraph(cor, bg = "#F7F35F", groups = grupos)


Nodos

color

É um argumento que recebe uma cor para cada nodo, ou uma cor para cada elementos em um grupo, ou uma cor para todos os nodos. O padrão é “white” quando o bg está no default (white).


  • Uma cor para todos os nodos
qgraph(input, color = "black")


  • Uma cor para cada nodo
qgraph(input, color = c("white", "red", "blue"))


  • Uma cor para cada grupo
qgraph(cor, groups = grupos, color = c("#3371FF", "#6EFF33"))


Observe que, com o argumento groups, o R entendeu que a primeira cor deveria colorir o grupo 1 e a segunda cor o grupo 2.


vsize

Um valor que indica o tamanho dos nodos. Pode ser um vetor que tenha um tamanho específico para cada nodo. Por exemplo, você pode querer que o tamanho dos nodos varie de acordo com a média das variáveis.

## cria um vetor com as medias de cada variavel do bfi
media <- sapply(bfi, mean)

qgraph(cor, vsize = media) ## os nodos vao mudar de tamanho de acordo com a media


borders

É lógico (TRUE é o default) e indica se as bordas dos nodos devem ser plotadas. Se você colocar FALSE, os nodos ficam sem bordas.

qgraph(cor, borders = FALSE)


border.color

Cor da borda dos nodos. Pode ser uma cor para cada nodo ou uma cor para todos.

qgraph(input, border.color = "red")

## uma cor para cada nodo

qgraph(input, border.color = c("red", "black", "green"))

## um vetor de cores

colors <- c("red", "green", "yellow", "black", "gray", "red", "green", "yellow", "black", "gray")

qgraph(cor, border.color = colors)


border.width

Um valor que muda a espessura da borda. O default é 2. Quanto menor o número, menor a borda. Esse argumento pode ser combinado com o argumento do pie.border, para deixar a borda um pouco mais limpa.

qgraph(cor, border.width = 4)


shape

Um nome que indica o formato do nodo. O default é "circle". Pode ser "square" (retângulo é igual a square) "triangle" and "diamond". Pode também ser um vetor que indica o formato de cada nodo.

shapes <- c("diamond", "square", "triangle")
qgraph(input, shape = shapes)


vTrans

Um número de 0 a 255 que muda a transparência do nodo. Quanto menor, mais transparente.

qgraph(cor, color = "blue", vTrans = 150)


nodeNames

Define os nomes para cada nodo. Quando usado, uma legenda é criada (se legend = TRUE, o que é o default) ao lado da rede, indicando o nome de cada nodo. Segue a ordem das colunas dos dados que você colocou como entrada. Você pode definir os nomes de cada nodo e colocar em um vetor.

nomes <- c("Variável 1", "Variável 2", "Variável 3")
qgraph(input, nodeNames = nomes)

## se voce quiser colocar o nome das colunas da matriz de correlacao como nodeNames:

nomes2 <- colnames(cor)
qgraph(cor, nodeNames = nomes2)

## Ou

qgraph(cor, nodeNames = colnames(cor))


Rótulos dos nodos (node labels)

labels

Argumento para colocar/tirar o que vai dentro dos nodos (como se fosse o nome de cada nodo). Se FALSE, nada é colocado. Se TRUE (default), os nomes que estão na matriz (provavelmente vai ser o nome das colunas ou uma sequência de números) usada para fazer a rede vão ser usados. Você também pode colocar como argumento um vetor. Sugestão: faça um vetor de números que tenha a mesma quantidade de nodos (ex: 10 nodos, então c(1:10)) ou um vetor com abreviações dos nomes das colunas (e.g., c("Le", "Os", Ps"...)).

## vetor de 1:3 porque temos 3 nodos

qgraph(input, labels = c(1:3))

## um nome para cada nodo. Se voce tiver 50 nodos, precisara de 50 nomes

nodos <- c("Dó", "Ré", "Mi") 
qgraph(input, labels = nodos, nodeNames = nomes)


label.cex

Um número que indica o tamanho dos labels dentro dos nodos. Um argumento já é usado para ajustar o tamanho dos labels dentro de cada nodo.


label.color

A cor das labels. Default é "black". Pode ser uma cor para cada label. Cada nodo fica com uma cor.

qgraph(input, label.color = c("black", "blue", "red"))


Arestas

edge.color

É um nome de cor para mudar a cor das arestas. Pode ser uma única cor para mudar a cor de todas as arestas. Pode ser uma matriz com uma cor para cada aresta (quando se está usando uma matriz ponderada). No entanto, quando você estima uma rede por mgm e dados categóricos/ordinais são relacionados, eles formaram arestas de cor cinza (o próprio mgm vai retornar essas arestas). Por isso, nesses modelos, o ideal é colocar edge.color = onomedoseuobjeto$edgecolor.


posCol

Muda a cor das aresta positivas. Pode ser um vetor de tamanho 2 indicando a cor que os edges que estão abaixo e acima do valor do argumento cut vão ter.


negCol

Muda a cor da arestas negativas. Pode ser um vetor de tamanho 2 indicando a cor que os edges que estão abaixo e acima do valor do argumento cut vão ter.

qgraph(cor, posCol = "#FFCE33", negCol = "#50D3C1")


negDashed

É lógico. Se for TRUE, os edges negativos vão ficar pontilhados. Quando o theme = "gray", essa argumento é “ligado” automaticamente.

qgraph(cor, negDashed = TRUE)


Curvatura das arestas

Esses argumentos controlam a curvatura das arestas. O default é que elas sejam retas. Porém, você pode mudar isso caso ache necessário ou veja que arestas curvadas podem melhorar a visualização.


curveAll

Lógico e indica se todas as arestas devem ser curvadas com o valor de curve ou apenas arestas entre os nodos que compartilham várias arestas. O default é 1.

qgraph(cor, curveAll = TRUE)


curve

É um valor que indica o quão forte as arestas devem ser curvadas. Pode ser um único valor (que vai ser aplicado para todas as arestas) ou um vetor com um valor para cada aresta. O valor recomendado para curvas ótimas é 0.3. Porém, você pode escolher um valor que melhor se ajusta a sua rede. Deve ser usado junto com curveAll.

qgraph(cor, curveAll = TRUE, curve = 0.3)


Rótulos das arestas (edge labels)

Podemos fazer com que os valores das arestas também apareçam na rede.


edge.labels

Lógico. Default é FALSE. Se for TRUE, os valores de cada aresta é colocado em cima da aresta.

qgraph(cor, edge.labels = TRUE)


edge.label.cex

Um número ou uma lista de números que indica o tamanho dos valores de cada aresta. O default é 1.

qgraph(cor, edge.labels = TRUE, edge.label.cex = 0.6)


edge.label.bg

Pode ser lógico ou um vetor/matriz. Indica a cor de fundo dos valores das arestas. Se for TRUE (default), a cor de fundo é branca. Você pode colocar um nome de uma cor ou fazer um vetor com uma cor para cada aresta. Se FALSE, nenhuma cor é colocada.

qgraph(cor, edge.labels = TRUE, edge.label.bg = "yellow")


edge.label.position

É um vetor numérico de 0 a 1 que controla a posição relativa de cada label das arestas. O default é 0.5, o que coloca cada label no centro da aresta.

qgraph(cor, edge.labels = TRUE, edge.label.position = 0.3)


edge.label.color

Vetor de caracteres indicando a cor das labels das arestas. Pode ser um vetor de cores de comprimento igual ao número de arestas na rede ou uma cor, que será aplicada a todas as arestas.

qgraph(cor, edge.labels = TRUE, edge.label.color = "black", edge.label.position = 0.3)



Argumentos de interpretação

Três argumentos da função qgraph() podem ser importantes para interpretar/modificar a visualização de redes ponderadas.


minimum

Arestas com valores absolutos (desconsiderando o sinal) abaixo desse valor não são mostradas. O padrão é 0. Pode ser mudado para “sig” para mostrar apenas as arestas significativas para graph = "cor" (correlações) e "pcor" (correlações parciais). O nível de significância é controlado pelos argumentos alphae bonf.


cut

Se especificado, divide a escala de largura e saturação de cor. As arestas com valores absolutos acima desse valor terão a intensidade de cor mais forte e se tornarão mais amplas quanto mais fortes, e as arestas com valores absolutos abaixo desse valor terão a menor largura e se tornarão mais vagas quanto mais fraco for o valor. Se estiver definido como 0, nenhum corte será usado e todas as arestas variam em largura e cor. O padrão é 0 (normalmente, é mantido como 0).


maximum

Se definido, a largura da aresta e a escala de cores mudam de forma que uma aresta com esse valor vai ser a mais larga e colorida. A aresta com o valor mais alto na rede será a referência para esse argumento.

Para vermos esses três argumentos na rede, é só colocar details = TRUE (se o minimum for 0, ele não vai aparecer na rede).

qgraph(cor, maximum = 1, details = TRUE) ## com maximum 1, a aresta mais grossa sera a de valor 1

qgraph(cor, minimum = 0.3, details = TRUE) ## arestas menores que 0.3 nao foram mostradas

qgraph(cor, cut = 0.4, details = TRUE) ## arestas iguais ou menores de 0.4 ficam do mesmo tamanho

## os passos de cima em uma unica rede

qgraph(cor, maximum = 1, minimum = 0.3, cut = 0.4, details = TRUE)



Argumentos de posicionamento

layout

A localização dos nodos é especificada pelo argumento layout.

O input desse argumento pode ser uma matriz N x 2, indicando a posição x e y de cada nodo.

O layout também pode ser "circular" (os nodos são colocados em círculo). Se o argumento groups estiver colocado, cada grupo de nodos forma um círculo separado.

E também pode ser "spring", que usa um algoritmo (Fruchterman-Reingold) para colocar os nodos em posições que facilitem a visualização. Em princípio, esse algoritmo faz com que cada nodo (conectado e não conectado) se repulse, e os nodos conectados se atraem. Depois de várias iterações (500 por padrão), nas quais o deslocamento máximo de cada nodo se torna menor, é obtido um layout no qual a distância entre os nodos corresponde muito bem ao valor absoluto da aresta entre esses nodos. Isso significa que nodos que não estão conectados vão ficar mais longe um do outro, enquanto que nodos altamente conectados vão ficar próximos.

No entanto, não podemos olhar para os nodos que estão no centro da rede e assumir que esses nodos são “centrais” para a rede.

Normalmente, usamos "spring".

qgraph(cor, layout = "spring")


repulsion

Um número que modifica o raio de repulsão do layout = "spring". O padrão é 1. Definir esse argumento para valores mais baixos (por exemplo, 0.5) fará com que os nodos no layout = "spring" se repulsem (se afastem um do outro) menos.

qgraph(cor, layout = "spring", repulsion = 1, title = "repulsion = 1 (default)")

qgraph(cor, layout = "spring", repulsion = 0.5, title = "repulsion = 0.5")

qgraph(cor, layout = "spring", repulsion = 1.5, title = "repulsion = 1.5")



Comparando redes

Vamos carregar duas redes como exemplo:

par(mfrow = c(1,2))
rede1 <- qgraph(cor, layout = "spring")
rede2 <- qgraph(cor*(-0.5), layout = "circular")


Para comparar redes, é necessário que o layout de todas as redes seja o mesmo. Normalmente, usa-se a função AverageLayout() para estimar o layout das redes que se quer comparar.

Essa função recebe como argumentos as matrizes das redes ou as próprias redes. Precisamos colocar o resultado da função em um objeto. A gente vai usar esse objeto no argumento layout dentro da função qgraph().

newlayout <- averageLayout(rede1, rede2)


Isso vai deixar as redes com o mesmo “formato”. Só que, na hora de plotar, é legal que a gente veja as duas redes, uma do lado da outra. Para isso, precisamos usar a função par(mfrow = c(x,y)), onde x é o número de linhas e y o número de colunas. Para que essa função funcione em um documento R markdown, é necessário rodar a função par() e as redes, tudo junto.

par(mfrow = c(1, 2))

qgraph(rede1, layout = newlayout)
qgraph(rede2, layout = newlayout)


Uma coisa muito importante para fazer quando se está comparando redes é definir o argumento maximum para as redes. Esse argumento receberá o valor mais alto da aresta de uma das redes (ou seja, é o mesmo valor para todas as redes). Para sabermos qual é esse valor, usamos details = TRUE nas duas redes:

par(mfrow = c(1,2))
qgraph(rede1, details = TRUE, layout = newlayout)
qgraph(rede2, details = TRUE, layout = newlayout)


Observamos qual é o valor de maximum para cada rede. Depois, adicionamos essa informação na função qgraph(). De acordo com as redes acima, vemos que o maximum da primeira rede é 0.57 e o da segunda é 0.29. Assim, vamos colocar maximum = 0.57 para as duas redes.

par(mfrow = c(1,2))
qgraph(rede1, maximum = 0.57, layout = newlayout)
qgraph(rede2, maximum = 0.57, layout = newlayout)


O valor de maximum vai fazer com que a aresta com maior valor seja a aresta mais grossa (e.g., 0.57). Assim, vamos conseguir distinguir o tamanho das arestas das redes que estamos comparando.



Pie charts e predictabilidade

Em psicometria, os gráficos de pizza/torta (pie charts) podem ser usados na rede para que a predictabilidade dos nodos seja visualizada. Entenda mais sobre em Predictability in Network Models.

Para entendermos como esses argumentos funcionam, vamos estimar um Mixed Graphical Models com o pacote mgm. Esse pacote permite que façamos a predictabilidade dos nodos.

library(mgm)

# vamos continuar usando o dataset "bfi", com 10 variaveis

rede_est <- mgm(bfi, type = rep("g", 10),
                level = rep(1, 10),
                rule = "AND",
                criterion = "EBIC")


E a predictabilidade:

rede_pred <- predict(rede_est, data = bfi,
                     errorCon = "R2")

erros <- rede_pred$errors$R2

No vetor erros, temos a predictabilidade dos nodos. Agora, precisamos plotar na rede. Para isso, vamos usar alguns argumentos.


pie

Um vetor que indica os valores do gráfico de tortas para cada nodo. Deve ser um vetor de 0 a 1. Lembrando que a predictabilidade vai de 0 a 1. Também, pode ser uma lista com vetores para criar gráficos de pizza de várias partes. O gráfico vai ficar na borda do nodo.

qgraph(rede_est$pairwise$wadj, pie = erros)


pieBorder

O tamanho do gráfico de pizza na borda. Valor entre 0 e 1. O default é 0.15. Se você colocar 1, todo o nodo vira um gráfico de pizza. Pode também ser um vetor com um valor para cada nodo.

qgraph(rede_est$pairwise$wadj, pie = erros, pieBorder = 1)


pieColor

Cores das partes do gráfico de pizza. Pode ser uma cor para todos os nodos, um vetor com um valor para cada nodo ou uma lista com vários valores, se houver mais partes.

qgraph(rede_est$pairwise$wadj, pie = erros, pieBorder = 0.3, pieColor = "blue")



Como salvar as redes?

pdf()

Para as redes terem melhor resolução, salve em pdf. É possível salvar várias redes em um mesmo pdf. Lembre-se: execute todos as linhas de uma vez! Você também pode salvar em png, o processo é o mesmo. Veja se, o resultado de dev.off() é null device = 1. Caso não seja, execute dev.off() até aparecer esse resultado.

Para a rede ficar maior no pdf, a opção width = 16 e height = 10 pode ser útil. Caso seja necessário salvar a rede no tamanho de um A4, colocar width = 10 e height = 10. Porém, você pode ajustar essas medidas para o tamanho que achar mais adequado.

A rede será salva no seu diretório de trabalho (para saber qual é, getwd()). Como exemplo, vamos salvar um pdf com duas redes, uma ao lado da outra.

pdf("rede.pdf", width = 16, height = 10)
par(mfrow = c(1,2))
qgraph(cor)
qgraph(cor)
dev.off()
## null device 
##           1


qgraph()

O próprio qgraph() tem dois argumentos específicos para salvar as redes. Porém, com esses argumentos, não é possível salvar várias redes, uma ao lado da outra, por exemplo. Por outro lado, o ponto positivo desses argumentos é que eles facilitam o trabalho com legendas grandes.

O arquivo ficará salvo no seu diretório de trabalho.


filetype

Especifica o tipo de arquivo. pdf é uma boa opção.


filename

Especifica o nome do arquivo.

qgraph(cor, filetype = "pdf", filename = "rede")



Não plotar redes, plotar redes novamente e reutilizar layouts

Não plotar redes

DoNotPlot

É lógico. Default é FALSE. Quando TRUE, a rede não é plotada. É útil quando você deseja criar uma rede, salvá-la em algum objeto e não plotá-la.

rede <- qgraph(cor, DoNotPlot = TRUE)


Plotar redes novamente e reutilizar layouts

Se o resultado de qgraph estiver armazenado, como graph <- qgraph(...), o gráfico poderá ser recriado de duas maneiras.

  1. qgraph(graph, ...) executa o qgraph novamente com os mesmos argumentos usados na chamada original, exceto aqueles adicionados na reticências. Por exemplo, qgraph(graph, shape = "square") recriará o mesmo gráfico, mas agora usará nodos quadrados em vez de circulares.

  2. plot(graph) NÃO executará novamente o qgraph, mas simplesmente plotará o objeto qgraph. Isso significa que atributos gráficos específicos podem ser alterados antes da plotagem. Mais específico, qgraph(graph) baseará o novo gráfico apenas no elemento Arguments do objeto qgraph e plot(graph) baseará o novo gráfico nos elementos graphAttributes e plotOptions do objeto qgraph.

Para reutilizar um layout, use o elemento de layout. Por exemplo, para plotar um novo gráfico com o mesmo layout, use qgraph(..., layout = graph$layout).



Como ver os argumentos que foram usados na rede?

Depois que a rede foi plotada, você pode querer checar quais argumentos estão presentes na sua rede (aqueles que você escolheu e também aqueles que o qgraph() coloca como default), bem como ver os valores desses argumentos.

Para que você consiga ver os argumentos, é necessário que a rede seja salva em um objeto.

lab_nodos <- c("A1","A2","A3","A4","A5","C1","C2","C3","C4","C5") ## labels para nodos
grupos <- c(rep("Agreeableness",5), rep("Consciousness", 5)) ## grupos
nomes_nodos <- paste(rep("Esse é o nodo", 10), lab_nodos) ## nomes para nodos

rede <- qgraph(cor, layout = "spring",
               theme = "Borkulo",
               groups = grupos,
               color = c("#12F78B", "#B212F7"),
               title = "Rede",
               title.cex = 1.5,
               legend.cex = 0.5,
               labels = lab_nodos,
               nodeNames = nomes_nodos,
               borders = FALSE)


Agora, vamos checar dentro do objeto rede. Para isso, vamos usar rede$plotOptions$ e escolher o argumento que queremos checar.

## tamanho da legenda
rede$plotOptions$legend.cex
## [1] 0.5
## altura da figura
rede$plotOptions$height
## [1] 7
## margens
rede$plotOptions$mar
## [1] 0.3 0.3 0.3 0.3

Você pode explorar outros argumentos e outras opções, como rede$Edgelist.




flow()


Essa função serve para criar redes como um diagrama de fluxo que mostra como um nodo específico está conectado com os outros nodos.

Além dos argumentos “próprios” dessa função, ela também pode comportar os argumentos da função qgraph().


Argumentos

O primeiro argumento é a rede criada pelo qgraph(). Em seguida, coloca-se o argumento from. Esse argumento indica qual nodo será o foco dessa nova rede. Se você definiu labels para os nodos, especifique a label do nodo.

rede <- qgraph(cor, layout = "spring", labels = c(1:10))

flow(rede, from = 1)


unfadeFirst

Lógico. Quando TRUE, as arestas entre o nodo de interesse e os outros nodos da rede são realçadas.

flow(rede, from = 1, unfadeFirst = TRUE)


Existem outros argumentos não abordados nesse tutorial, mas que podem ser estudados na documentação do pacote.



Referências

Epskamp, S., Constantini, G., Halsbeck, J., Isvoranu, A., Cramer, A. O. J., Waldorp, L. J., Schmittmann, V. D., Borsboom, D. (2020). qgraph: Graph Plotting Methods, Psychometric Data Visualization and Graphical Model Estimation. R package version 1.6.5. https://cran.r-project.org/web/packages/qgraph/qgraph.pdf.

Epskamp, S., Cramer, A. O. J., Waldorp, L. J., Schmittmann, V. D., Borsboom, D. (2012). qgraph: Network Visualizations of Relationships in Psychometric Data. Journal of Statistical Software, 48(4), 1–18. http://www.jstatsoft.org/v48/i04/.

Halsbeck, J. (2016). Predictability in Network Models. https://jmbh.github.io/Predictability-in-network-models/.